
/*
 */

import {JSCons} from "../core/EasyACons";
import {_} from "./UtilTs";

export class TsReflect{

    static getClass<T=any>(instance):T{
        return Object.getPrototypeOf(instance).constructor;
    }

    static getProto (func){
        return Object.getPrototypeOf(func);
    }


    static setProps(instance,props){
        for (let k in props){
            instance[k] = props[k]
        }
    }

    static createInstance<T>(clazz):T{
        return new clazz();
    }

    //只获取除 构造方法以外的所有方法
    static getFunctionFuncFields(func,thisbind?){
        let ret:any =_(Object.getOwnPropertyNames(func))

            .filter((item)=> item != JSCons.sConstructor) //排除构造方法(名)
            .zipObject()         //转成object
            .value();

        _.each(ret,(val,key)=>{
            if(_.isFunction(func[key])){
                ret[key] = thisbind ? func[key].bind(thisbind) : func[key];
            }
        });
        return ret;
    }

    //获取一个class(function)的，除了构造方法以外的方法
    static getClassMethods = (clazz):any=> TsReflect.getFunctionFuncFields(clazz.prototype);

    static getClassProtoMethods = (clazz):any=> TsReflect.getClassMethods(Object.getPrototypeOf(clazz));

    //获取实例自己的在__proto__上的除了构造以外的方法名
    static getFuncProtoMethods = (func):any=> TsReflect.getFunctionFuncFields(Object.getPrototypeOf(func),func);


    static hasInProto(ins,keyName){
        const proto = TsReflect.getProto(ins);
        return proto.hasOwnProperty(keyName)
    }

    static isExtendsFromClazz(clazz,FromClass):boolean{
        const proto = FromClass.prototype;
        return  proto.isPrototypeOf(clazz);
    }



}
